package com.prim.background;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 线程安全问题
 * 第一种：运行结果出错
 * 演示计数不准确（减少），找出具体出错的位置
 */
public class MultiThreadsError implements Runnable {

    int index = 0;

    static MultiThreadsError instance = new MultiThreadsError();

    final boolean[] marked = new boolean[10000000];

    static AtomicInteger realIndex = new AtomicInteger();
    static AtomicInteger wrongCount = new AtomicInteger();

    //CyclicBarrier 让线程根据我们的需要在某个地方等待，直到所等待的人员都就绪了，在一起出发 parties :2 表示等待两个线程
    static volatile CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
    static volatile CyclicBarrier cyclicBarrier2 = new CyclicBarrier(2);

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(instance);
        Thread thread2 = new Thread(instance);
        thread1.start();
        thread2.start();
        thread1.join();//等待线程1执行完毕
        thread2.join();//等待线程2执行完毕
        System.out.println(instance.index);
        System.out.println("realIndex:" + realIndex.get());
        System.out.println("wrongCount:" + wrongCount.get());

    }

    @Override
    public void run() {
        marked[0] = true;
        for (int i = 0; i < 10000; i++) {
            try {
                cyclicBarrier2.reset();
                //标记等待点 当两个线程都运行到这个点之后 一起执行
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            index++;
            try {
                //等待两个线程都执行完了 index++操作 然后放行
                cyclicBarrier.reset();
                cyclicBarrier2.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            realIndex.incrementAndGet();
            //但是存在问题 如果两个线程都执行完了index++ 操作这时候 synchronized只能有一个线程去执行
            //第一个线程执行 marked=true 而第二个线程index是一样的 执行的时候marked肯定为true 所以第二个线程肯定会打印
            //解决问题加入判断：marked[index - 1] 前一位是true
            //存在没有线程冲突的情况 很可能有没有被标记上。
            //比如 10 = true 11 = false 12 = true 正常的情况
            //错误情况 10 = true 11 = true 12
            synchronized (instance) {
                if (marked[index] && marked[index - 1]) {
                    System.out.println("发生了错误:" + index);
                    wrongCount.incrementAndGet();
                }
                marked[index] = true;
            }
        }
    }
}
